<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>MathArrays (Apache Commons Math 3.3 API)</title>
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="MathArrays (Apache Commons Math 3.3 API)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/MathArrays.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/commons/math3/util/IterationManager.html" title="class in org.apache.commons.math3.util"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/apache/commons/math3/util/MathArrays.Function.html" title="interface in org.apache.commons.math3.util"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/commons/math3/util/MathArrays.html" target="_top">Frames</a></li>
<li><a href="MathArrays.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested_class_summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.commons.math3.util</div>
<h2 title="Class MathArrays" class="title">Class MathArrays</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.commons.math3.util.MathArrays</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="strong">MathArrays</span>
extends <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">Arrays utilities.</div>
<dl><dt><span class="strong">Since:</span></dt>
  <dd>3.0</dd>
<dt><span class="strong">Version:</span></dt>
  <dd>$Id: MathArrays.java 1591835 2014-05-02 09:04:01Z tn $</dd></dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested_class_summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Nested Class Summary table, listing nested classes, and an explanation">
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Class and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.Function.html" title="interface in org.apache.commons.math3.util">MathArrays.Function</a></strong></code>
<div class="block">Real-valued function that operate on an array or a part of it.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static class&nbsp;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a></strong></code>
<div class="block">Specification of ordering direction.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static class&nbsp;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html" title="enum in org.apache.commons.math3.util">MathArrays.Position</a></strong></code>
<div class="block">Specification for indicating that some operation applies
 before or after a given index.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static &lt;T&gt;&nbsp;T[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#buildArray(org.apache.commons.math3.Field, int)">buildArray</a></strong>(<a href="../../../../../org/apache/commons/math3/Field.html" title="interface in org.apache.commons.math3">Field</a>&lt;T&gt;&nbsp;field,
          int&nbsp;length)</code>
<div class="block">Build an array of elements.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static &lt;T&gt;&nbsp;T[][]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#buildArray(org.apache.commons.math3.Field, int, int)">buildArray</a></strong>(<a href="../../../../../org/apache/commons/math3/Field.html" title="interface in org.apache.commons.math3">Field</a>&lt;T&gt;&nbsp;field,
          int&nbsp;rows,
          int&nbsp;columns)</code>
<div class="block">Build a double dimension  array of elements.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkNonNegative(long[])">checkNonNegative</a></strong>(long[]&nbsp;in)</code>
<div class="block">Check that all entries of the input array are >= 0.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkNonNegative(long[][])">checkNonNegative</a></strong>(long[][]&nbsp;in)</code>
<div class="block">Check all entries of the input array are >= 0.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkOrder(double[])">checkOrder</a></strong>(double[]&nbsp;val)</code>
<div class="block">Check that the given array is sorted in strictly increasing order.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkOrder(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">checkOrder</a></strong>(double[]&nbsp;val,
          <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
          boolean&nbsp;strict)</code>
<div class="block">Check that the given array is sorted.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkOrder(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean, boolean)">checkOrder</a></strong>(double[]&nbsp;val,
          <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
          boolean&nbsp;strict,
          boolean&nbsp;abort)</code>
<div class="block">Check that the given array is sorted.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkPositive(double[])">checkPositive</a></strong>(double[]&nbsp;in)</code>
<div class="block">Check that all entries of the input array are strictly positive.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#checkRectangular(long[][])">checkRectangular</a></strong>(long[][]&nbsp;in)</code>
<div class="block">Throws DimensionMismatchException if the input array is not rectangular.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#convolve(double[], double[])">convolve</a></strong>(double[]&nbsp;x,
        double[]&nbsp;h)</code>
<div class="block">Calculates the <a href="http://en.wikipedia.org/wiki/Convolution">
 convolution</a> between two sequences.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#copyOf(double[])">copyOf</a></strong>(double[]&nbsp;source)</code>
<div class="block">Creates a copy of the <code>source</code> array.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#copyOf(double[], int)">copyOf</a></strong>(double[]&nbsp;source,
      int&nbsp;len)</code>
<div class="block">Creates a copy of the <code>source</code> array.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#copyOf(int[])">copyOf</a></strong>(int[]&nbsp;source)</code>
<div class="block">Creates a copy of the <code>source</code> array.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#copyOf(int[], int)">copyOf</a></strong>(int[]&nbsp;source,
      int&nbsp;len)</code>
<div class="block">Creates a copy of the <code>source</code> array.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distance(double[], double[])">distance</a></strong>(double[]&nbsp;p1,
        double[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>2</sub> (Euclidean) distance between two points.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distance(int[], int[])">distance</a></strong>(int[]&nbsp;p1,
        int[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>2</sub> (Euclidean) distance between two points.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distance1(double[], double[])">distance1</a></strong>(double[]&nbsp;p1,
         double[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>1</sub> (sum of abs) distance between two points.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distance1(int[], int[])">distance1</a></strong>(int[]&nbsp;p1,
         int[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>1</sub> (sum of abs) distance between two points.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distanceInf(double[], double[])">distanceInf</a></strong>(double[]&nbsp;p1,
           double[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>&infin;</sub> (max of abs) distance between two points.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#distanceInf(int[], int[])">distanceInf</a></strong>(int[]&nbsp;p1,
           int[]&nbsp;p2)</code>
<div class="block">Calculates the L<sub>&infin;</sub> (max of abs) distance between two points.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#ebeAdd(double[], double[])">ebeAdd</a></strong>(double[]&nbsp;a,
      double[]&nbsp;b)</code>
<div class="block">Creates an array whose contents will be the element-by-element
 addition of the arguments.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#ebeDivide(double[], double[])">ebeDivide</a></strong>(double[]&nbsp;a,
         double[]&nbsp;b)</code>
<div class="block">Creates an array whose contents will be the element-by-element
 division of the first argument by the second.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#ebeMultiply(double[], double[])">ebeMultiply</a></strong>(double[]&nbsp;a,
           double[]&nbsp;b)</code>
<div class="block">Creates an array whose contents will be the element-by-element
 multiplication of the arguments.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#ebeSubtract(double[], double[])">ebeSubtract</a></strong>(double[]&nbsp;a,
           double[]&nbsp;b)</code>
<div class="block">Creates an array whose contents will be the element-by-element
 subtraction of the second argument from the first.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#equals(double[], double[])">equals</a></strong>(double[]&nbsp;x,
      double[]&nbsp;y)</code>
<div class="block">Returns <code>true</code> iff both arguments are <code>null</code> or have same
 dimensions and all their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equals(double, double)"><code>Precision.equals(double,double)</code></a>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#equals(float[], float[])">equals</a></strong>(float[]&nbsp;x,
      float[]&nbsp;y)</code>
<div class="block">Returns true iff both arguments are null or have same dimensions and all
 their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equals(float, float)"><code>Precision.equals(float,float)</code></a>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#equalsIncludingNaN(double[], double[])">equalsIncludingNaN</a></strong>(double[]&nbsp;x,
                  double[]&nbsp;y)</code>
<div class="block">Returns <code>true</code> iff both arguments are <code>null</code> or have same
 dimensions and all their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equalsIncludingNaN(double, double)"><code>this method</code></a>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#equalsIncludingNaN(float[], float[])">equalsIncludingNaN</a></strong>(float[]&nbsp;x,
                  float[]&nbsp;y)</code>
<div class="block">Returns true iff both arguments are null or have same dimensions and all
 their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equalsIncludingNaN(double, double)"><code>this method</code></a>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#isMonotonic(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">isMonotonic</a></strong>(double[]&nbsp;val,
           <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
           boolean&nbsp;strict)</code>
<div class="block">Check that an array is monotonically increasing or decreasing.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static &lt;T extends <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html?is-external=true" title="class or interface in java.lang">Comparable</a>&lt;? super T&gt;&gt;&nbsp;<br>boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#isMonotonic(T[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">isMonotonic</a></strong>(T[]&nbsp;val,
           <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
           boolean&nbsp;strict)</code>
<div class="block">Check that an array is monotonically increasing or decreasing.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double[], double[])">linearCombination</a></strong>(double[]&nbsp;a,
                 double[]&nbsp;b)</code>
<div class="block">Compute a linear combination accurately.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double)">linearCombination</a></strong>(double&nbsp;a1,
                 double&nbsp;b1,
                 double&nbsp;a2,
                 double&nbsp;b2)</code>
<div class="block">Compute a linear combination accurately.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double)">linearCombination</a></strong>(double&nbsp;a1,
                 double&nbsp;b1,
                 double&nbsp;a2,
                 double&nbsp;b2,
                 double&nbsp;a3,
                 double&nbsp;b3)</code>
<div class="block">Compute a linear combination accurately.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double, double, double)">linearCombination</a></strong>(double&nbsp;a1,
                 double&nbsp;b1,
                 double&nbsp;a2,
                 double&nbsp;b2,
                 double&nbsp;a3,
                 double&nbsp;b3,
                 double&nbsp;a4,
                 double&nbsp;b4)</code>
<div class="block">Compute a linear combination accurately.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#natural(int)">natural</a></strong>(int&nbsp;n)</code>
<div class="block">Returns an array representing the natural number <code>n</code>.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#normalizeArray(double[], double)">normalizeArray</a></strong>(double[]&nbsp;values,
              double&nbsp;normalizedSum)</code>
<div class="block">Normalizes an array to make it sum to a specified value.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#safeNorm(double[])">safeNorm</a></strong>(double[]&nbsp;v)</code>
<div class="block">Returns the Cartesian norm (2-norm), handling both overflow and underflow.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#scale(double, double[])">scale</a></strong>(double&nbsp;val,
     double[]&nbsp;arr)</code>
<div class="block">Create a copy of an array scaled by a value.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#scaleInPlace(double, double[])">scaleInPlace</a></strong>(double&nbsp;val,
            double[]&nbsp;arr)</code>
<div class="block">Multiply each element of an array by a value.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[])">shuffle</a></strong>(int[]&nbsp;list)</code>
<div class="block">Shuffle the entries of the given array.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position)">shuffle</a></strong>(int[]&nbsp;list,
       int&nbsp;start,
       <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html" title="enum in org.apache.commons.math3.util">MathArrays.Position</a>&nbsp;pos)</code>
<div class="block">Shuffle the entries of the given array.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position, org.apache.commons.math3.random.RandomGenerator)">shuffle</a></strong>(int[]&nbsp;list,
       int&nbsp;start,
       <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html" title="enum in org.apache.commons.math3.util">MathArrays.Position</a>&nbsp;pos,
       <a href="../../../../../org/apache/commons/math3/random/RandomGenerator.html" title="interface in org.apache.commons.math3.random">RandomGenerator</a>&nbsp;rng)</code>
<div class="block">Shuffle the entries of the given array, using the
 <a href="http://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm">
 Fisher–Yates</a> algorithm.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], org.apache.commons.math3.random.RandomGenerator)">shuffle</a></strong>(int[]&nbsp;list,
       <a href="../../../../../org/apache/commons/math3/random/RandomGenerator.html" title="interface in org.apache.commons.math3.random">RandomGenerator</a>&nbsp;rng)</code>
<div class="block">Shuffle the entries of the given array.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#sortInPlace(double[], double[]...)">sortInPlace</a></strong>(double[]&nbsp;x,
           double[]...&nbsp;yList)</code>
<div class="block">Sort an array in ascending order in place and perform the same reordering
 of entries on other arrays.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#sortInPlace(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, double[]...)">sortInPlace</a></strong>(double[]&nbsp;x,
           <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
           double[]...&nbsp;yList)</code>
<div class="block">Sort an array in place and perform the same reordering of entries on
 other arrays.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#verifyValues(double[], double[], int, int)">verifyValues</a></strong>(double[]&nbsp;values,
            double[]&nbsp;weights,
            int&nbsp;begin,
            int&nbsp;length)</code>
<div class="block">This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#verifyValues(double[], double[], int, int, boolean)">verifyValues</a></strong>(double[]&nbsp;values,
            double[]&nbsp;weights,
            int&nbsp;begin,
            int&nbsp;length,
            boolean&nbsp;allowEmpty)</code>
<div class="block">This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#verifyValues(double[], int, int)">verifyValues</a></strong>(double[]&nbsp;values,
            int&nbsp;begin,
            int&nbsp;length)</code>
<div class="block">This method is used
 to verify that the input parameters designate a subarray of positive length.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#verifyValues(double[], int, int, boolean)">verifyValues</a></strong>(double[]&nbsp;values,
            int&nbsp;begin,
            int&nbsp;length,
            boolean&nbsp;allowEmpty)</code>
<div class="block">This method is used
 to verify that the input parameters designate a subarray of positive length.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang">clone</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang">equals</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang">finalize</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang">getClass</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang">hashCode</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang">notify</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang">notifyAll</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang">toString</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait(long, int)" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="scale(double, double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>scale</h4>
<pre>public static&nbsp;double[]&nbsp;scale(double&nbsp;val,
             double[]&nbsp;arr)</pre>
<div class="block">Create a copy of an array scaled by a value.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>arr</code> - Array to scale.</dd><dd><code>val</code> - Scalar.</dd>
<dt><span class="strong">Returns:</span></dt><dd>scaled copy of array with each entry multiplied by val.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.2</dd></dl>
</li>
</ul>
<a name="scaleInPlace(double, double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>scaleInPlace</h4>
<pre>public static&nbsp;void&nbsp;scaleInPlace(double&nbsp;val,
                double[]&nbsp;arr)</pre>
<div class="block"><p>Multiply each element of an array by a value.</p>

 <p>The array is modified in place (no copy is created).</p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>arr</code> - Array to scale</dd><dd><code>val</code> - Scalar</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.2</dd></dl>
</li>
</ul>
<a name="ebeAdd(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ebeAdd</h4>
<pre>public static&nbsp;double[]&nbsp;ebeAdd(double[]&nbsp;a,
              double[]&nbsp;b)
                       throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Creates an array whose contents will be the element-by-element
 addition of the arguments.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - First term of the addition.</dd><dd><code>b</code> - Second term of the addition.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array <code>r</code> where <code>r[i] = a[i] + b[i]</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if the array lengths differ.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="ebeSubtract(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ebeSubtract</h4>
<pre>public static&nbsp;double[]&nbsp;ebeSubtract(double[]&nbsp;a,
                   double[]&nbsp;b)
                            throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Creates an array whose contents will be the element-by-element
 subtraction of the second argument from the first.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - First term.</dd><dd><code>b</code> - Element to be subtracted.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array <code>r</code> where <code>r[i] = a[i] - b[i]</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if the array lengths differ.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="ebeMultiply(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ebeMultiply</h4>
<pre>public static&nbsp;double[]&nbsp;ebeMultiply(double[]&nbsp;a,
                   double[]&nbsp;b)
                            throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Creates an array whose contents will be the element-by-element
 multiplication of the arguments.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - First factor of the multiplication.</dd><dd><code>b</code> - Second factor of the multiplication.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array <code>r</code> where <code>r[i] = a[i] * b[i]</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if the array lengths differ.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="ebeDivide(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ebeDivide</h4>
<pre>public static&nbsp;double[]&nbsp;ebeDivide(double[]&nbsp;a,
                 double[]&nbsp;b)
                          throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Creates an array whose contents will be the element-by-element
 division of the first argument by the second.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - Numerator of the division.</dd><dd><code>b</code> - Denominator of the division.</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array <code>r</code> where <code>r[i] = a[i] / b[i]</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if the array lengths differ.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="distance1(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distance1</h4>
<pre>public static&nbsp;double&nbsp;distance1(double[]&nbsp;p1,
               double[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>1</sub> (sum of abs) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>1</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="distance1(int[], int[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distance1</h4>
<pre>public static&nbsp;int&nbsp;distance1(int[]&nbsp;p1,
            int[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>1</sub> (sum of abs) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>1</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="distance(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distance</h4>
<pre>public static&nbsp;double&nbsp;distance(double[]&nbsp;p1,
              double[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>2</sub> (Euclidean) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>2</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="distance(int[], int[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distance</h4>
<pre>public static&nbsp;double&nbsp;distance(int[]&nbsp;p1,
              int[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>2</sub> (Euclidean) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>2</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="distanceInf(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distanceInf</h4>
<pre>public static&nbsp;double&nbsp;distanceInf(double[]&nbsp;p1,
                 double[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>&infin;</sub> (max of abs) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>&infin;</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="distanceInf(int[], int[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>distanceInf</h4>
<pre>public static&nbsp;int&nbsp;distanceInf(int[]&nbsp;p1,
              int[]&nbsp;p2)</pre>
<div class="block">Calculates the L<sub>&infin;</sub> (max of abs) distance between two points.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>p1</code> - the first point</dd><dd><code>p2</code> - the second point</dd>
<dt><span class="strong">Returns:</span></dt><dd>the L<sub>&infin;</sub> distance between the two points</dd></dl>
</li>
</ul>
<a name="isMonotonic(java.lang.Comparable[],org.apache.commons.math3.util.MathArrays.OrderDirection,boolean)">
<!--   -->
</a><a name="isMonotonic(T[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isMonotonic</h4>
<pre>public static&nbsp;&lt;T extends <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html?is-external=true" title="class or interface in java.lang">Comparable</a>&lt;? super T&gt;&gt;&nbsp;boolean&nbsp;isMonotonic(T[]&nbsp;val,
                                                    <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
                                                    boolean&nbsp;strict)</pre>
<div class="block">Check that an array is monotonically increasing or decreasing.</div>
<dl><dt><span class="strong">Type Parameters:</span></dt><dd><code>T</code> - the type of the elements in the specified array</dd><dt><span class="strong">Parameters:</span></dt><dd><code>val</code> - Values.</dd><dd><code>dir</code> - Ordering direction.</dd><dd><code>strict</code> - Whether the order should be strict.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if sorted, <code>false</code> otherwise.</dd></dl>
</li>
</ul>
<a name="isMonotonic(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isMonotonic</h4>
<pre>public static&nbsp;boolean&nbsp;isMonotonic(double[]&nbsp;val,
                  <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
                  boolean&nbsp;strict)</pre>
<div class="block">Check that an array is monotonically increasing or decreasing.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>val</code> - Values.</dd><dd><code>dir</code> - Ordering direction.</dd><dd><code>strict</code> - Whether the order should be strict.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if sorted, <code>false</code> otherwise.</dd></dl>
</li>
</ul>
<a name="checkOrder(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkOrder</h4>
<pre>public static&nbsp;boolean&nbsp;checkOrder(double[]&nbsp;val,
                 <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
                 boolean&nbsp;strict,
                 boolean&nbsp;abort)
                          throws <a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></pre>
<div class="block">Check that the given array is sorted.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>val</code> - Values.</dd><dd><code>dir</code> - Ordering direction.</dd><dd><code>strict</code> - Whether the order should be strict.</dd><dd><code>abort</code> - Whether to throw an exception if the check fails.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if the array is sorted.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></code> - if the array is not sorted
 and <code>abort</code> is <code>true</code>.</dd></dl>
</li>
</ul>
<a name="checkOrder(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkOrder</h4>
<pre>public static&nbsp;void&nbsp;checkOrder(double[]&nbsp;val,
              <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
              boolean&nbsp;strict)
                       throws <a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></pre>
<div class="block">Check that the given array is sorted.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>val</code> - Values.</dd><dd><code>dir</code> - Ordering direction.</dd><dd><code>strict</code> - Whether the order should be strict.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></code> - if the array is not sorted.</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.2</dd></dl>
</li>
</ul>
<a name="checkOrder(double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkOrder</h4>
<pre>public static&nbsp;void&nbsp;checkOrder(double[]&nbsp;val)
                       throws <a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></pre>
<div class="block">Check that the given array is sorted in strictly increasing order.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>val</code> - Values.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NonMonotonicSequenceException.html" title="class in org.apache.commons.math3.exception">NonMonotonicSequenceException</a></code> - if the array is not sorted.</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.2</dd></dl>
</li>
</ul>
<a name="checkRectangular(long[][])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkRectangular</h4>
<pre>public static&nbsp;void&nbsp;checkRectangular(long[][]&nbsp;in)
                             throws <a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a>,
                                    <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Throws DimensionMismatchException if the input array is not rectangular.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>in</code> - array to be tested</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></code> - if input array is null</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if input array is not rectangular</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="checkPositive(double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkPositive</h4>
<pre>public static&nbsp;void&nbsp;checkPositive(double[]&nbsp;in)
                          throws <a href="../../../../../org/apache/commons/math3/exception/NotStrictlyPositiveException.html" title="class in org.apache.commons.math3.exception">NotStrictlyPositiveException</a></pre>
<div class="block">Check that all entries of the input array are strictly positive.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>in</code> - Array to be tested</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NotStrictlyPositiveException.html" title="class in org.apache.commons.math3.exception">NotStrictlyPositiveException</a></code> - if any entries of the array are not
 strictly positive.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="checkNonNegative(long[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkNonNegative</h4>
<pre>public static&nbsp;void&nbsp;checkNonNegative(long[]&nbsp;in)
                             throws <a href="../../../../../org/apache/commons/math3/exception/NotPositiveException.html" title="class in org.apache.commons.math3.exception">NotPositiveException</a></pre>
<div class="block">Check that all entries of the input array are >= 0.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>in</code> - Array to be tested</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NotPositiveException.html" title="class in org.apache.commons.math3.exception">NotPositiveException</a></code> - if any array entries are less than 0.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="checkNonNegative(long[][])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkNonNegative</h4>
<pre>public static&nbsp;void&nbsp;checkNonNegative(long[][]&nbsp;in)
                             throws <a href="../../../../../org/apache/commons/math3/exception/NotPositiveException.html" title="class in org.apache.commons.math3.exception">NotPositiveException</a></pre>
<div class="block">Check all entries of the input array are >= 0.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>in</code> - Array to be tested</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NotPositiveException.html" title="class in org.apache.commons.math3.exception">NotPositiveException</a></code> - if any array entries are less than 0.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd></dl>
</li>
</ul>
<a name="safeNorm(double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>safeNorm</h4>
<pre>public static&nbsp;double&nbsp;safeNorm(double[]&nbsp;v)</pre>
<div class="block">Returns the Cartesian norm (2-norm), handling both overflow and underflow.
 Translation of the minpack enorm subroutine.

 The redistribution policy for MINPACK is available
 <a href="http://www.netlib.org/minpack/disclaimer">here</a>, for
 convenience, it is reproduced below.</p>

 <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
 <tr><td>
    Minpack Copyright Notice (1999) University of Chicago.
    All rights reserved
 </td></tr>
 <tr><td>
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 <ol>
  <li>Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.</li>
 <li>Redistributions in binary form must reproduce the above
     copyright notice, this list of conditions and the following
     disclaimer in the documentation and/or other materials provided
     with the distribution.</li>
 <li>The end-user documentation included with the redistribution, if any,
     must include the following acknowledgment:
     <code>This product includes software developed by the University of
           Chicago, as Operator of Argonne National Laboratory.</code>
     Alternately, this acknowledgment may appear in the software itself,
     if and wherever such third-party acknowledgments normally appear.</li>
 <li><strong>WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS"
     WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE
     UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND
     THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR
     IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES
     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE
     OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY
     OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR
     USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF
     THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4)
     DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION
     UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL
     BE CORRECTED.</strong></li>
 <li><strong>LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT
     HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF
     ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT,
     INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF
     ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF
     PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER
     SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT
     (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE,
     EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE
     POSSIBILITY OF SUCH LOSS OR DAMAGES.</strong></li>
 <ol></td></tr>
 </table></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>v</code> - Vector of doubles.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the 2-norm of the vector.</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.2</dd></dl>
</li>
</ul>
<a name="sortInPlace(double[], double[]...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sortInPlace</h4>
<pre>public static&nbsp;void&nbsp;sortInPlace(double[]&nbsp;x,
               double[]...&nbsp;yList)
                        throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a>,
                               <a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></pre>
<div class="block">Sort an array in ascending order in place and perform the same reordering
 of entries on other arrays. For example, if
 <code>x = [3, 1, 2], y = [1, 2, 3]</code> and <code>z = [0, 5, 7]</code>, then
 <code>sortInPlace(x, y, z)</code> will update <code>x</code> to <code>[1, 2, 3]</code>,
 <code>y</code> to <code>[2, 3, 1]</code> and <code>z</code> to <code>[5, 7, 0]</code>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - Array to be sorted and used as a pattern for permutation
 of the other arrays.</dd><dd><code>yList</code> - Set of arrays whose permutations of entries will follow
 those performed on <code>x</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if any <code>y</code> is not the same
 size as <code>x</code>.</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></code> - if <code>x</code> or any <code>y</code> is null.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.0</dd></dl>
</li>
</ul>
<a name="sortInPlace(double[], org.apache.commons.math3.util.MathArrays.OrderDirection, double[]...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sortInPlace</h4>
<pre>public static&nbsp;void&nbsp;sortInPlace(double[]&nbsp;x,
               <a href="../../../../../org/apache/commons/math3/util/MathArrays.OrderDirection.html" title="enum in org.apache.commons.math3.util">MathArrays.OrderDirection</a>&nbsp;dir,
               double[]...&nbsp;yList)
                        throws <a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a>,
                               <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Sort an array in place and perform the same reordering of entries on
 other arrays.  This method works the same as the other
 <a href="../../../../../org/apache/commons/math3/util/MathArrays.html#sortInPlace(double[], double[]...)"><code>sortInPlace</code></a> method, but
 allows the order of the sort to be provided in the <code>dir</code>
 parameter.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - Array to be sorted and used as a pattern for permutation
 of the other arrays.</dd><dd><code>dir</code> - Order direction.</dd><dd><code>yList</code> - Set of arrays whose permutations of entries will follow
 those performed on <code>x</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if any <code>y</code> is not the same
 size as <code>x</code>.</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></code> - if <code>x</code> or any <code>y</code> is null</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.0</dd></dl>
</li>
</ul>
<a name="copyOf(int[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>copyOf</h4>
<pre>public static&nbsp;int[]&nbsp;copyOf(int[]&nbsp;source)</pre>
<div class="block">Creates a copy of the <code>source</code> array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>source</code> - Array to be copied.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the copied array.</dd></dl>
</li>
</ul>
<a name="copyOf(double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>copyOf</h4>
<pre>public static&nbsp;double[]&nbsp;copyOf(double[]&nbsp;source)</pre>
<div class="block">Creates a copy of the <code>source</code> array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>source</code> - Array to be copied.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the copied array.</dd></dl>
</li>
</ul>
<a name="copyOf(int[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>copyOf</h4>
<pre>public static&nbsp;int[]&nbsp;copyOf(int[]&nbsp;source,
           int&nbsp;len)</pre>
<div class="block">Creates a copy of the <code>source</code> array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>source</code> - Array to be copied.</dd><dd><code>len</code> - Number of entries to copy. If smaller then the source
 length, the copy will be truncated, if larger it will padded with
 zeroes.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the copied array.</dd></dl>
</li>
</ul>
<a name="copyOf(double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>copyOf</h4>
<pre>public static&nbsp;double[]&nbsp;copyOf(double[]&nbsp;source,
              int&nbsp;len)</pre>
<div class="block">Creates a copy of the <code>source</code> array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>source</code> - Array to be copied.</dd><dd><code>len</code> - Number of entries to copy. If smaller then the source
 length, the copy will be truncated, if larger it will padded with
 zeroes.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the copied array.</dd></dl>
</li>
</ul>
<a name="linearCombination(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public static&nbsp;double&nbsp;linearCombination(double[]&nbsp;a,
                       double[]&nbsp;b)
                                throws <a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Compute a linear combination accurately.
 This method computes the sum of the products
 <code>a<sub>i</sub> b<sub>i</sub></code> to high accuracy.
 It does so by using specific multiplication and addition algorithms to
 preserve accuracy and reduce cancellation effects.
 <br/>
 It is based on the 2005 paper
 <a href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.2.1547">
 Accurate Sum and Dot Product</a> by Takeshi Ogita, Siegfried M. Rump,
 and Shin'ichi Oishi published in SIAM J. Sci. Comput.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - Factors.</dd><dd><code>b</code> - Factors.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>&Sigma;<sub>i</sub> a<sub>i</sub> b<sub>i</sub></code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if arrays dimensions don't match</dd></dl>
</li>
</ul>
<a name="linearCombination(double, double, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public static&nbsp;double&nbsp;linearCombination(double&nbsp;a1,
                       double&nbsp;b1,
                       double&nbsp;a2,
                       double&nbsp;b2)</pre>
<div class="block">Compute a linear combination accurately.
 <p>
 This method computes a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub> to high accuracy. It does
 so by using specific multiplication and addition algorithms to
 preserve accuracy and reduce cancellation effects. It is based
 on the 2005 paper <a
 href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.2.1547">
 Accurate Sum and Dot Product</a> by Takeshi Ogita,
 Siegfried M. Rump, and Shin'ichi Oishi published in SIAM J. Sci. Comput.
 </p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first factor of the first term</dd><dd><code>b1</code> - second factor of the first term</dd><dd><code>a2</code> - first factor of the second term</dd><dd><code>b2</code> - second factor of the second term</dd>
<dt><span class="strong">Returns:</span></dt><dd>a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double)"><code>linearCombination(double, double, double, double, double, double)</code></a>, 
<a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double, double, double)"><code>linearCombination(double, double, double, double, double, double, double, double)</code></a></dd></dl>
</li>
</ul>
<a name="linearCombination(double, double, double, double, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public static&nbsp;double&nbsp;linearCombination(double&nbsp;a1,
                       double&nbsp;b1,
                       double&nbsp;a2,
                       double&nbsp;b2,
                       double&nbsp;a3,
                       double&nbsp;b3)</pre>
<div class="block">Compute a linear combination accurately.
 <p>
 This method computes a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub> + a<sub>3</sub>&times;b<sub>3</sub>
 to high accuracy. It does so by using specific multiplication and
 addition algorithms to preserve accuracy and reduce cancellation effects.
 It is based on the 2005 paper <a
 href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.2.1547">
 Accurate Sum and Dot Product</a> by Takeshi Ogita,
 Siegfried M. Rump, and Shin'ichi Oishi published in SIAM J. Sci. Comput.
 </p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first factor of the first term</dd><dd><code>b1</code> - second factor of the first term</dd><dd><code>a2</code> - first factor of the second term</dd><dd><code>b2</code> - second factor of the second term</dd><dd><code>a3</code> - first factor of the third term</dd><dd><code>b3</code> - second factor of the third term</dd>
<dt><span class="strong">Returns:</span></dt><dd>a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub> + a<sub>3</sub>&times;b<sub>3</sub></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double)"><code>linearCombination(double, double, double, double)</code></a>, 
<a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double, double, double)"><code>linearCombination(double, double, double, double, double, double, double, double)</code></a></dd></dl>
</li>
</ul>
<a name="linearCombination(double, double, double, double, double, double, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public static&nbsp;double&nbsp;linearCombination(double&nbsp;a1,
                       double&nbsp;b1,
                       double&nbsp;a2,
                       double&nbsp;b2,
                       double&nbsp;a3,
                       double&nbsp;b3,
                       double&nbsp;a4,
                       double&nbsp;b4)</pre>
<div class="block">Compute a linear combination accurately.
 <p>
 This method computes a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub> + a<sub>3</sub>&times;b<sub>3</sub> +
 a<sub>4</sub>&times;b<sub>4</sub>
 to high accuracy. It does so by using specific multiplication and
 addition algorithms to preserve accuracy and reduce cancellation effects.
 It is based on the 2005 paper <a
 href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.2.1547">
 Accurate Sum and Dot Product</a> by Takeshi Ogita,
 Siegfried M. Rump, and Shin'ichi Oishi published in SIAM J. Sci. Comput.
 </p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first factor of the first term</dd><dd><code>b1</code> - second factor of the first term</dd><dd><code>a2</code> - first factor of the second term</dd><dd><code>b2</code> - second factor of the second term</dd><dd><code>a3</code> - first factor of the third term</dd><dd><code>b3</code> - second factor of the third term</dd><dd><code>a4</code> - first factor of the third term</dd><dd><code>b4</code> - second factor of the third term</dd>
<dt><span class="strong">Returns:</span></dt><dd>a<sub>1</sub>&times;b<sub>1</sub> +
 a<sub>2</sub>&times;b<sub>2</sub> + a<sub>3</sub>&times;b<sub>3</sub> +
 a<sub>4</sub>&times;b<sub>4</sub></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double)"><code>linearCombination(double, double, double, double)</code></a>, 
<a href="../../../../../org/apache/commons/math3/util/MathArrays.html#linearCombination(double, double, double, double, double, double)"><code>linearCombination(double, double, double, double, double, double)</code></a></dd></dl>
</li>
</ul>
<a name="equals(float[], float[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equals</h4>
<pre>public static&nbsp;boolean&nbsp;equals(float[]&nbsp;x,
             float[]&nbsp;y)</pre>
<div class="block">Returns true iff both arguments are null or have same dimensions and all
 their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equals(float, float)"><code>Precision.equals(float,float)</code></a>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - first array</dd><dd><code>y</code> - second array</dd>
<dt><span class="strong">Returns:</span></dt><dd>true if the values are both null or have same dimension
 and equal elements.</dd></dl>
</li>
</ul>
<a name="equalsIncludingNaN(float[], float[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equalsIncludingNaN</h4>
<pre>public static&nbsp;boolean&nbsp;equalsIncludingNaN(float[]&nbsp;x,
                         float[]&nbsp;y)</pre>
<div class="block">Returns true iff both arguments are null or have same dimensions and all
 their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equalsIncludingNaN(double, double)"><code>this method</code></a>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - first array</dd><dd><code>y</code> - second array</dd>
<dt><span class="strong">Returns:</span></dt><dd>true if the values are both null or have same dimension and
 equal elements</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.2</dd></dl>
</li>
</ul>
<a name="equals(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equals</h4>
<pre>public static&nbsp;boolean&nbsp;equals(double[]&nbsp;x,
             double[]&nbsp;y)</pre>
<div class="block">Returns <code>true</code> iff both arguments are <code>null</code> or have same
 dimensions and all their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equals(double, double)"><code>Precision.equals(double,double)</code></a>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - First array.</dd><dd><code>y</code> - Second array.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if the values are both <code>null</code> or have same
 dimension and equal elements.</dd></dl>
</li>
</ul>
<a name="equalsIncludingNaN(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equalsIncludingNaN</h4>
<pre>public static&nbsp;boolean&nbsp;equalsIncludingNaN(double[]&nbsp;x,
                         double[]&nbsp;y)</pre>
<div class="block">Returns <code>true</code> iff both arguments are <code>null</code> or have same
 dimensions and all their elements are equal as defined by
 <a href="../../../../../org/apache/commons/math3/util/Precision.html#equalsIncludingNaN(double, double)"><code>this method</code></a>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - First array.</dd><dd><code>y</code> - Second array.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if the values are both <code>null</code> or have same
 dimension and equal elements.</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.2</dd></dl>
</li>
</ul>
<a name="normalizeArray(double[], double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>normalizeArray</h4>
<pre>public static&nbsp;double[]&nbsp;normalizeArray(double[]&nbsp;values,
                      double&nbsp;normalizedSum)
                               throws <a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a>,
                                      <a href="../../../../../org/apache/commons/math3/exception/MathArithmeticException.html" title="class in org.apache.commons.math3.exception">MathArithmeticException</a></pre>
<div class="block">Normalizes an array to make it sum to a specified value.
 Returns the result of the transformation
 <pre>
    x |-> x * normalizedSum / sum
 </pre>
 applied to each non-NaN element x of the input array, where sum is the
 sum of the non-NaN entries in the input array.
 <p>
 Throws IllegalArgumentException if <code>normalizedSum</code> is infinite
 or NaN and ArithmeticException if the input array contains any infinite elements
 or sums to 0.
 <p>
 Ignores (i.e., copies unchanged to the output array) NaNs in the input array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - Input array to be normalized</dd><dd><code>normalizedSum</code> - Target sum for the normalized array</dd>
<dt><span class="strong">Returns:</span></dt><dd>the normalized array.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathArithmeticException.html" title="class in org.apache.commons.math3.exception">MathArithmeticException</a></code> - if the input array contains infinite
 elements or sums to zero.</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></code> - if the target sum is infinite or <code>NaN</code>.</dd><dt><span class="strong">Since:</span></dt>
  <dd>2.1</dd></dl>
</li>
</ul>
<a name="buildArray(org.apache.commons.math3.Field, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildArray</h4>
<pre>public static&nbsp;&lt;T&gt;&nbsp;T[]&nbsp;buildArray(<a href="../../../../../org/apache/commons/math3/Field.html" title="interface in org.apache.commons.math3">Field</a>&lt;T&gt;&nbsp;field,
                 int&nbsp;length)</pre>
<div class="block">Build an array of elements.
 <p>
 Arrays are filled with field.getZero()</div>
<dl><dt><span class="strong">Type Parameters:</span></dt><dd><code>T</code> - the type of the field elements</dd><dt><span class="strong">Parameters:</span></dt><dd><code>field</code> - field to which array elements belong</dd><dd><code>length</code> - of the array</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.2</dd></dl>
</li>
</ul>
<a name="buildArray(org.apache.commons.math3.Field, int, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>buildArray</h4>
<pre>public static&nbsp;&lt;T&gt;&nbsp;T[][]&nbsp;buildArray(<a href="../../../../../org/apache/commons/math3/Field.html" title="interface in org.apache.commons.math3">Field</a>&lt;T&gt;&nbsp;field,
                   int&nbsp;rows,
                   int&nbsp;columns)</pre>
<div class="block">Build a double dimension  array of elements.
 <p>
 Arrays are filled with field.getZero()</div>
<dl><dt><span class="strong">Type Parameters:</span></dt><dd><code>T</code> - the type of the field elements</dd><dt><span class="strong">Parameters:</span></dt><dd><code>field</code> - field to which array elements belong</dd><dd><code>rows</code> - number of rows in the array</dd><dd><code>columns</code> - number of columns (may be negative to build partial
 arrays in the same way <code>new Field[rows][]</code> works)</dd>
<dt><span class="strong">Returns:</span></dt><dd>a new array</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.2</dd></dl>
</li>
</ul>
<a name="convolve(double[], double[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>convolve</h4>
<pre>public static&nbsp;double[]&nbsp;convolve(double[]&nbsp;x,
                double[]&nbsp;h)
                         throws <a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a>,
                                <a href="../../../../../org/apache/commons/math3/exception/NoDataException.html" title="class in org.apache.commons.math3.exception">NoDataException</a></pre>
<div class="block">Calculates the <a href="http://en.wikipedia.org/wiki/Convolution">
 convolution</a> between two sequences.
 <p>
 The solution is obtained via straightforward computation of the
 convolution sum (and not via FFT). Whenever the computation needs
 an element that would be located at an index outside the input arrays,
 the value is assumed to be zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - First sequence.
 Typically, this sequence will represent an input signal to a system.</dd><dd><code>h</code> - Second sequence.
 Typically, this sequence will represent the impulse response of the system.</dd>
<dt><span class="strong">Returns:</span></dt><dd>the convolution of <code>x</code> and <code>h</code>.
 This array's length will be <code>x.length + h.length - 1</code>.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></code> - if either <code>x</code> or <code>h</code> is <code>null</code>.</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NoDataException.html" title="class in org.apache.commons.math3.exception">NoDataException</a></code> - if either <code>x</code> or <code>h</code> is empty.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
<a name="shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>shuffle</h4>
<pre>public static&nbsp;void&nbsp;shuffle(int[]&nbsp;list,
           int&nbsp;start,
           <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html" title="enum in org.apache.commons.math3.util">MathArrays.Position</a>&nbsp;pos)</pre>
<div class="block">Shuffle the entries of the given array.
 The <code>start</code> and <code>pos</code> parameters select which portion
 of the array is randomized and which is left untouched.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>list</code> - Array whose entries will be shuffled (in-place).</dd><dd><code>start</code> - Index at which shuffling begins.</dd><dd><code>pos</code> - Shuffling is performed for index positions between
 <code>start</code> and either the end (if <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html#TAIL"><code>MathArrays.Position.TAIL</code></a>)
 or the beginning (if <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html#HEAD"><code>MathArrays.Position.HEAD</code></a>) of the array.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position, org.apache.commons.math3.random.RandomGenerator)"><code>shuffle(int[],int,Position,RandomGenerator)</code></a></dd></dl>
</li>
</ul>
<a name="shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position, org.apache.commons.math3.random.RandomGenerator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>shuffle</h4>
<pre>public static&nbsp;void&nbsp;shuffle(int[]&nbsp;list,
           int&nbsp;start,
           <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html" title="enum in org.apache.commons.math3.util">MathArrays.Position</a>&nbsp;pos,
           <a href="../../../../../org/apache/commons/math3/random/RandomGenerator.html" title="interface in org.apache.commons.math3.random">RandomGenerator</a>&nbsp;rng)</pre>
<div class="block">Shuffle the entries of the given array, using the
 <a href="http://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm">
 Fisher–Yates</a> algorithm.
 The <code>start</code> and <code>pos</code> parameters select which portion
 of the array is randomized and which is left untouched.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>list</code> - Array whose entries will be shuffled (in-place).</dd><dd><code>start</code> - Index at which shuffling begins.</dd><dd><code>pos</code> - Shuffling is performed for index positions between
 <code>start</code> and either the end (if <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html#TAIL"><code>MathArrays.Position.TAIL</code></a>)
 or the beginning (if <a href="../../../../../org/apache/commons/math3/util/MathArrays.Position.html#HEAD"><code>MathArrays.Position.HEAD</code></a>) of the array.</dd><dd><code>rng</code> - Random number generator.</dd></dl>
</li>
</ul>
<a name="shuffle(int[], org.apache.commons.math3.random.RandomGenerator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>shuffle</h4>
<pre>public static&nbsp;void&nbsp;shuffle(int[]&nbsp;list,
           <a href="../../../../../org/apache/commons/math3/random/RandomGenerator.html" title="interface in org.apache.commons.math3.random">RandomGenerator</a>&nbsp;rng)</pre>
<div class="block">Shuffle the entries of the given array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>list</code> - Array whose entries will be shuffled (in-place).</dd><dd><code>rng</code> - Random number generator.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position, org.apache.commons.math3.random.RandomGenerator)"><code>shuffle(int[],int,Position,RandomGenerator)</code></a></dd></dl>
</li>
</ul>
<a name="shuffle(int[])">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>shuffle</h4>
<pre>public static&nbsp;void&nbsp;shuffle(int[]&nbsp;list)</pre>
<div class="block">Shuffle the entries of the given array.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>list</code> - Array whose entries will be shuffled (in-place).</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/commons/math3/util/MathArrays.html#shuffle(int[], int, org.apache.commons.math3.util.MathArrays.Position, org.apache.commons.math3.random.RandomGenerator)"><code>shuffle(int[],int,Position,RandomGenerator)</code></a></dd></dl>
</li>
</ul>
<a name="natural(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>natural</h4>
<pre>public static&nbsp;int[]&nbsp;natural(int&nbsp;n)</pre>
<div class="block">Returns an array representing the natural number <code>n</code>.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>n</code> - Natural number.</dd>
<dt><span class="strong">Returns:</span></dt><dd>an array whose entries are the numbers 0, 1, ..., <code>n</code>-1.
 If <code>n == 0</code>, the returned array is empty.</dd></dl>
</li>
</ul>
<a name="verifyValues(double[], int, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>verifyValues</h4>
<pre>public static&nbsp;boolean&nbsp;verifyValues(double[]&nbsp;values,
                   int&nbsp;begin,
                   int&nbsp;length)
                            throws <a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></pre>
<div class="block">This method is used
 to verify that the input parameters designate a subarray of positive length.
 <p>
 <ul>
 <li>returns <code>true</code> iff the parameters designate a subarray of
 positive length</li>
 <li>throws <code>MathIllegalArgumentException</code> if the array is null or
 or the indices are invalid</li>
 <li>returns <code>false</li> if the array is non-null, but
 <code>length</code> is 0.
 </ul></p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - the input array</dd><dd><code>begin</code> - index of the first array element to include</dd><dd><code>length</code> - the number of elements to include</dd>
<dt><span class="strong">Returns:</span></dt><dd>true if the parameters are valid and designate a subarray of positive length</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></code> - if the indices are invalid or the array is null</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
<a name="verifyValues(double[], int, int, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>verifyValues</h4>
<pre>public static&nbsp;boolean&nbsp;verifyValues(double[]&nbsp;values,
                   int&nbsp;begin,
                   int&nbsp;length,
                   boolean&nbsp;allowEmpty)
                            throws <a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></pre>
<div class="block">This method is used
 to verify that the input parameters designate a subarray of positive length.
 <p>
 <ul>
 <li>returns <code>true</code> iff the parameters designate a subarray of
 non-negative length</li>
 <li>throws <code>IllegalArgumentException</code> if the array is null or
 or the indices are invalid</li>
 <li>returns <code>false</li> if the array is non-null, but
 <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>
 </ul></p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - the input array</dd><dd><code>begin</code> - index of the first array element to include</dd><dd><code>length</code> - the number of elements to include</dd><dd><code>allowEmpty</code> - if <code>true</code> then zero length arrays are allowed</dd>
<dt><span class="strong">Returns:</span></dt><dd>true if the parameters are valid</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></code> - if the indices are invalid or the array is null</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
<a name="verifyValues(double[], double[], int, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>verifyValues</h4>
<pre>public static&nbsp;boolean&nbsp;verifyValues(double[]&nbsp;values,
                   double[]&nbsp;weights,
                   int&nbsp;begin,
                   int&nbsp;length)
                            throws <a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></pre>
<div class="block">This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero.
 <p>
 <ul>
 <li>returns <code>true</code> iff the parameters designate a subarray of
 positive length and the weights array contains legitimate values.</li>
 <li>throws <code>IllegalArgumentException</code> if any of the following are true:
 <ul><li>the values array is null</li>
     <li>the weights array is null</li>
     <li>the weights array does not have the same length as the values array</li>
     <li>the weights array contains one or more infinite values</li>
     <li>the weights array contains one or more NaN values</li>
     <li>the weights array contains negative values</li>
     <li>the start and length arguments do not determine a valid array</li></ul>
 </li>
 <li>returns <code>false</li> if the array is non-null, but
 <code>length</code> is 0.
 </ul></p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - the input array</dd><dd><code>weights</code> - the weights array</dd><dd><code>begin</code> - index of the first array element to include</dd><dd><code>length</code> - the number of elements to include</dd>
<dt><span class="strong">Returns:</span></dt><dd>true if the parameters are valid and designate a subarray of positive length</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></code> - if the indices are invalid or the array is null</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
<a name="verifyValues(double[], double[], int, int, boolean)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>verifyValues</h4>
<pre>public static&nbsp;boolean&nbsp;verifyValues(double[]&nbsp;values,
                   double[]&nbsp;weights,
                   int&nbsp;begin,
                   int&nbsp;length,
                   boolean&nbsp;allowEmpty)
                            throws <a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></pre>
<div class="block">This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero.
 <p>
 <ul>
 <li>returns <code>true</code> iff the parameters designate a subarray of
 non-negative length and the weights array contains legitimate values.</li>
 <li>throws <code>MathIllegalArgumentException</code> if any of the following are true:
 <ul><li>the values array is null</li>
     <li>the weights array is null</li>
     <li>the weights array does not have the same length as the values array</li>
     <li>the weights array contains one or more infinite values</li>
     <li>the weights array contains one or more NaN values</li>
     <li>the weights array contains negative values</li>
     <li>the start and length arguments do not determine a valid array</li></ul>
 </li>
 <li>returns <code>false</li> if the array is non-null, but
 <code>length</code> is 0 unless <code>allowEmpty</code> is <code>true</code>.
 </ul></p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - the input array.</dd><dd><code>weights</code> - the weights array.</dd><dd><code>begin</code> - index of the first array element to include.</dd><dd><code>length</code> - the number of elements to include.</dd><dd><code>allowEmpty</code> - if <code>true</code> than allow zero length arrays to pass.</dd>
<dt><span class="strong">Returns:</span></dt><dd><code>true</code> if the parameters are valid.</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/NullArgumentException.html" title="class in org.apache.commons.math3.exception">NullArgumentException</a></code> - if either of the arrays are null</dd>
<dd><code><a href="../../../../../org/apache/commons/math3/exception/MathIllegalArgumentException.html" title="class in org.apache.commons.math3.exception">MathIllegalArgumentException</a></code> - if the array indices are not valid,
 the weights array contains NaN, infinite or negative elements, or there
 are no positive weights.</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/MathArrays.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/commons/math3/util/IterationManager.html" title="class in org.apache.commons.math3.util"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/apache/commons/math3/util/MathArrays.Function.html" title="interface in org.apache.commons.math3.util"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/commons/math3/util/MathArrays.html" target="_top">Frames</a></li>
<li><a href="MathArrays.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested_class_summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2003&#x2013;2014 <a href="http://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
